ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಸಿಂಕ್ ಸಂದರ್ಭದ ವೇರಿಯಬಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್: ಸಂದರ್ಭ ಪ್ರಸರಣ ಸರಪಳಿಯಲ್ಲಿ ಪ್ರಾವೀಣ್ಯತೆ

ಅಸಿಂಕ್ರೊನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪ್‌ಮೆಂಟ್‌ನ ಅಡಿಗಲ್ಲು, ವಿಶೇಷವಾಗಿ Node.js ಮತ್ತು ಬ್ರೌಸರ್ ಪರಿಸರಗಳಲ್ಲಿ. ಇದು ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುವಾಗ, ಇದು ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಸಹ ಪರಿಚಯಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಸಂದರ್ಭವನ್ನು ನಿರ್ವಹಿಸುವಾಗ. ಲಾಗಿಂಗ್, ದೃಢೀಕರಣ, ಟ್ರೇಸಿಂಗ್, ಮತ್ತು ವಿನಂತಿ ನಿರ್ವಹಣೆಯಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸರಪಳಿಯಾದ್ಯಂತ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಸಂಬಂಧಿತ ಡೇಟಾ ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಇಲ್ಲಿಯೇ ಸರಿಯಾದ ಅಸಿಂಕ್ ಸಂದರ್ಭದ ವೇರಿಯಬಲ್ ಇನ್ಹೆರಿಟೆನ್ಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಅತ್ಯಗತ್ಯವಾಗುತ್ತದೆ.

ಅಸಿಂಕ್ರೊನಸ್ ಸಂದರ್ಭದ ಸವಾಲುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಸಿಂಕ್ರೊನಸ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು ಸರಳವಾಗಿದೆ. ಪೇರೆಂಟ್ ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಘೋಷಿಸಲಾದ ವೇರಿಯಬಲ್‌ಗಳು ಚೈಲ್ಡ್ ಸ್ಕೋಪ್‌ಗಳಲ್ಲಿ ಸುಲಭವಾಗಿ ಲಭ್ಯವಿರುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಈ ಸರಳ ಮಾದರಿಯನ್ನು ಅಡ್ಡಿಪಡಿಸುತ್ತವೆ. ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು, ಪ್ರಾಮಿಸ್‌ಗಳು, ಮತ್ತು async/await ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಂದರ್ಭವು ಬದಲಾಗಬಹುದಾದ ಬಿಂದುಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ, ಸಂಭಾವ್ಯವಾಗಿ ಪ್ರಮುಖ ಡೇಟಾಗೆ ಪ್ರವೇಶವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತವೆ. ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

            function processRequest(req, res) {
  const userId = req.headers['user-id'];

  setTimeout(() => {
    // Problem: How do we access userId here?
    console.log(`Processing request for user: ${userId}`); // userId might be undefined!
    res.send('Request processed');
  }, 1000);
}

            

              
                Copy
              
            
          

ಈ ಸರಳೀಕೃತ ಸನ್ನಿವೇಶದಲ್ಲಿ, ವಿನಂತಿಯ ಹೆಡರ್‌ಗಳಿಂದ ಪಡೆದ `userId` ಅನ್ನು `setTimeout` ಕಾಲ್‌ಬ್ಯಾಕ್‌ನಲ್ಲಿ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗದಿರಬಹುದು. ಏಕೆಂದರೆ ಕಾಲ್‌ಬ್ಯಾಕ್ ಬೇರೆ ಈವೆಂಟ್ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ, ಇದು ಮೂಲ ಸಂದರ್ಭವನ್ನು ಕಳೆದುಕೊಳ್ಳುವ ಸಾಧ್ಯತೆಯಿದೆ.

AsyncLocalStorage ಅನ್ನು ಪರಿಚಯಿಸಲಾಗುತ್ತಿದೆ

Node.js 14 ರಲ್ಲಿ ಪರಿಚಯಿಸಲಾದ AsyncLocalStorage, ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಹಿಂಪಡೆಯಲು ಒಂದು ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಇತರ ಭಾಷೆಗಳಲ್ಲಿನ ಥ್ರೆಡ್-ಲೋಕಲ್ ಸ್ಟೋರೇಜ್‌ನಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಈವೆಂಟ್-ಡ್ರೈವನ್, ನಾನ್-ಬ್ಲಾಕಿಂಗ್ ಪರಿಸರಕ್ಕಾಗಿ ವಿಶೇಷವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

AsyncLocalStorage ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

AsyncLocalStorage ಅಸಿಂಕ್ರೊನಸ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಂದರ್ಭದ ಸಂಪೂರ್ಣ ಜೀವಿತಾವಧಿಯಲ್ಲಿ ತನ್ನ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವ ಸ್ಟೋರೇಜ್ ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭವು `await` ಕರೆಗಳು, ಪ್ರಾಮಿಸ್‌ಗಳು ಮತ್ತು ಇತರ ಅಸಿಂಕ್ರೊನಸ್ ಗಡಿಗಳಾದ್ಯಂತ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರಸಾರವಾಗುತ್ತದೆ, ಸಂಗ್ರಹಿಸಲಾದ ಡೇಟಾ ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

AsyncLocalStorage ನ ಮೂಲಭೂತ ಬಳಕೆ

            const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

function processRequest(req, res) {
  const userId = req.headers['user-id'];

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('userId', userId);

    setTimeout(() => {
      const currentUserId = asyncLocalStorage.getStore().get('userId');
      console.log(`Processing request for user: ${currentUserId}`);
      res.send('Request processed');
    }, 1000);
  });
}

            

              
                Copy
              
            
          

ಈ ಪರಿಷ್ಕೃತ ಉದಾಹರಣೆಯಲ್ಲಿ, `AsyncLocalStorage.run()` ಒಂದು ಆರಂಭಿಕ ಸ್ಟೋರ್‌ನೊಂದಿಗೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು `Map`) ಹೊಸ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಂದರ್ಭವನ್ನು ರಚಿಸುತ್ತದೆ. ನಂತರ `userId` ಅನ್ನು `asyncLocalStorage.getStore().set()` ಬಳಸಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. `setTimeout` ಕಾಲ್‌ಬ್ಯಾಕ್‌ನೊಳಗೆ, `asyncLocalStorage.getStore().get()` ಸಂದರ್ಭದಿಂದ `userId` ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ, ಅಸಿಂಕ್ರೊನಸ್ ವಿಳಂಬದ ನಂತರವೂ ಅದು ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು: ಸ್ಟೋರ್ ಮತ್ತು ರನ್

• ಸ್ಟೋರ್: ಸ್ಟೋರ್ ನಿಮ್ಮ ಸಂದರ್ಭ ಡೇಟಾಗೆ ಒಂದು ಕಂಟೇನರ್ ಆಗಿದೆ. ಇದು ಯಾವುದೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್ ಆಗಿರಬಹುದು, ಆದರೆ `Map` ಅಥವಾ ಸರಳ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಸ್ಟೋರ್ ಪ್ರತಿ ಅಸಿಂಕ್ರೊನಸ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಸಂದರ್ಭಕ್ಕೂ ವಿಶಿಷ್ಟವಾಗಿರುತ್ತದೆ.
• ರನ್: `run()` ಮೆಥೆಡ್ AsyncLocalStorage ಇನ್‌ಸ್ಟೆನ್ಸ್‌ನ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡುತ್ತದೆ. ಇದು ಒಂದು ಸ್ಟೋರ್ ಮತ್ತು ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಆ ಕಾಲ್‌ಬ್ಯಾಕ್‌ನೊಳಗಿನ ಎಲ್ಲವೂ (ಮತ್ತು ಅದು ಪ್ರಚೋದಿಸುವ ಯಾವುದೇ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು) ಆ ಸ್ಟೋರ್‌ಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

AsyncResource: ನೇಟಿವ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು

AsyncLocalStorage ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್‌ನಲ್ಲಿ ಸಂದರ್ಭ ಪ್ರಸರಣಕ್ಕೆ ಪ್ರಬಲವಾದ ಯಾಂತ್ರಿಕತೆಯನ್ನು ಒದಗಿಸಿದರೂ, ಇದು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಪ್ರವೇಶ ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳಂತಹ ನೇಟಿವ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವಿಸ್ತರಿಸುವುದಿಲ್ಲ. AsyncResource ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪ್ರಸ್ತುತ AsyncLocalStorage ಸಂದರ್ಭದೊಂದಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮೂಲಕ ಈ ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

AsyncResource ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

AsyncResource ನಿಮಗೆ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯ ಒಂದು ಪ್ರತಿನಿಧೀಕರಣವನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಇದನ್ನು AsyncLocalStorage ಮೂಲಕ ಟ್ರ್ಯಾಕ್ ಮಾಡಬಹುದು. ಇದು AsyncLocalStorage ಸಂದರ್ಭವನ್ನು ನೇಟಿವ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು ಅಥವಾ ಪ್ರಾಮಿಸ್‌ಗಳಿಗೆ ಸರಿಯಾಗಿ ಪ್ರಸಾರ ಮಾಡುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.

AsyncResource ಅನ್ನು ಬಳಸುವುದು

            const { AsyncLocalStorage } = require('async_hooks');
const { AsyncResource } = require('async_hooks');
const fs = require('fs');

const asyncLocalStorage = new AsyncLocalStorage();

function processRequest(req, res) {
  const userId = req.headers['user-id'];

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('userId', userId);

    const resource = new AsyncResource('file-read-operation');

    fs.readFile('data.txt', 'utf8', (err, data) => {
      resource.runInAsyncScope(() => {
        const currentUserId = asyncLocalStorage.getStore().get('userId');
        console.log(`Processing data for user ${currentUserId}: ${data.length} bytes read`);
        res.send('Request processed');
        resource.emitDestroy();
      });
    });
  });
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `fs.readFile` ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಸುತ್ತುವರಿಯಲು `AsyncResource` ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. `resource.runInAsyncScope()` `fs.readFile` ಗಾಗಿ ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ AsyncLocalStorage ನ ಸಂದರ್ಭದಲ್ಲಿ ಎಕ್ಸಿಕ್ಯೂಟ್ ಆಗುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, `userId` ಅನ್ನು ಲಭ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ. ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಂಡ ನಂತರ ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಮತ್ತು ಮೆಮೊರಿ ಲೀಕ್‌ಗಳನ್ನು ತಡೆಯಲು `resource.emitDestroy()` ಕರೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಗಮನಿಸಿ: `emitDestroy()` ಅನ್ನು ಕರೆಯಲು ವಿಫಲವಾದರೆ ರಿಸೋರ್ಸ್ ಲೀಕ್‌ಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅಸ್ಥಿರತೆಗೆ ಕಾರಣವಾಗಬಹುದು.

ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು: ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್

• ರಿಸೋರ್ಸ್ ರಚನೆ: ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಒಂದು `AsyncResource` ಇನ್‌ಸ್ಟೆನ್ಸ್ ಅನ್ನು ರಚಿಸಿ. ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಒಂದು ಹೆಸರನ್ನು (ಡೀಬಗ್ಗಿಂಗ್‌ಗೆ ಬಳಸಲಾಗುತ್ತದೆ) ಮತ್ತು ಐಚ್ಛಿಕ `triggerAsyncId` ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
• ಸಂದರ್ಭ ಪ್ರಸರಣ: AsyncLocalStorage ಸಂದರ್ಭದಲ್ಲಿ ಕಾಲ್‌ಬ್ಯಾಕ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಎಕ್ಸಿಕ್ಯೂಟ್ ಮಾಡಲು `runInAsyncScope()` ಅನ್ನು ಬಳಸಿ.
• ರಿಸೋರ್ಸ್ ವಿನಾಶ: ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಂಡಾಗ `emitDestroy()` ಅನ್ನು ಕರೆಯಿರಿ.

ಸಂದರ್ಭ ಪ್ರಸರಣ ಸರಪಳಿಯನ್ನು ನಿರ್ಮಿಸುವುದು

AsyncLocalStorage ಮತ್ತು AsyncResource ನ ನಿಜವಾದ ಶಕ್ತಿಯು ಬಹು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಫಂಕ್ಷನ್ ಕರೆಗಳನ್ನು ವ್ಯಾಪಿಸುವ ಸಂದರ್ಭ ಪ್ರಸರಣ ಸರಪಳಿಯನ್ನು ರಚಿಸುವ ಸಾಮರ್ಥ್ಯದಲ್ಲಿದೆ. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಾದ್ಯಂತ ಸ್ಥಿರ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಸಂದರ್ಭವನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ಉದಾಹರಣೆ: ಬಹು-ಪದರದ ಅಸಿಂಕ್ರೊನಸ್ ಫ್ಲೋ

            const { AsyncLocalStorage } = require('async_hooks');
const { AsyncResource } = require('async_hooks');
const fs = require('fs');

const asyncLocalStorage = new AsyncLocalStorage();

async function fetchData() {
  return new Promise((resolve) => {
    const resource = new AsyncResource('data-fetch');
    fs.readFile('data.txt', 'utf8', (err, data) => {
      resource.runInAsyncScope(() => {
        resolve(data);
        resource.emitDestroy();
      });
    });
  });
}

async function processData(data) {
  const currentUserId = asyncLocalStorage.getStore().get('userId');
  console.log(`Processing data for user ${currentUserId}: ${data.length} bytes`);
  return `Processed by user ${currentUserId}: ${data.substring(0, 20)}...`;
}

async function sendResponse(processedData, res) {
  res.send(processedData);
}

function processRequest(req, res) {
  const userId = req.headers['user-id'];

  asyncLocalStorage.run(new Map(), async () => {
    asyncLocalStorage.getStore().set('userId', userId);

    const data = await fetchData();
    const processedData = await processData(data);
    await sendResponse(processedData, res);
  });
}

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, `processRequest` ಫ್ಲೋವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದು `userId` ನೊಂದಿಗೆ ಆರಂಭಿಕ ಸಂದರ್ಭವನ್ನು ಸ್ಥಾಪಿಸಲು `AsyncLocalStorage.run()` ಅನ್ನು ಬಳಸುತ್ತದೆ. `fetchData` `AsyncResource` ಬಳಸಿ ಫೈಲ್‌ನಿಂದ ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಡೇಟಾವನ್ನು ಓದುತ್ತದೆ. `processData` ನಂತರ AsyncLocalStorage ನಿಂದ `userId` ಅನ್ನು ಪ್ರವೇಶಿಸಿ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, `sendResponse` ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿದ ಡೇಟಾವನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ AsyncLocalStorage ಒದಗಿಸಿದ ಸಂದರ್ಭ ಪ್ರಸರಣದಿಂದಾಗಿ ಈ ಸಂಪೂರ್ಣ ಅಸಿಂಕ್ರೊನಸ್ ಸರಪಳಿಯಾದ್ಯಂತ `userId` ಲಭ್ಯವಿರುತ್ತದೆ.

ಸಂದರ್ಭ ಪ್ರಸರಣ ಸರಪಳಿಯ ಪ್ರಯೋಜನಗಳು

• ಸರಳೀಕೃತ ಲಾಗಿಂಗ್: ನಿಮ್ಮ ಲಾಗಿಂಗ್ ಲಾಜಿಕ್‌ನಲ್ಲಿ ವಿನಂತಿಗೆ-ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯನ್ನು (ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರ ಐಡಿ, ವಿನಂತಿ ಐಡಿ) ಬಹು ಫಂಕ್ಷನ್ ಕರೆಗಳ ಮೂಲಕ ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸದೆಯೇ ಪ್ರವೇಶಿಸಿ. ಇದು ಡೀಬಗ್ಗಿಂಗ್ ಮತ್ತು ಆಡಿಟಿಂಗ್ ಅನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
• ಕೇಂದ್ರೀಕೃತ ಕಾನ್ಫಿಗರೇಶನ್: ನಿರ್ದಿಷ್ಟ ವಿನಂತಿ ಅಥವಾ ಕಾರ್ಯಾಚರಣೆಗೆ ಸಂಬಂಧಿಸಿದ ಕಾನ್ಫಿಗರೇಶನ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು AsyncLocalStorage ಸಂದರ್ಭದಲ್ಲಿ ಸಂಗ್ರಹಿಸಿ. ಇದು ಸಂದರ್ಭದ ಆಧಾರದ ಮೇಲೆ ಅಪ್ಲಿಕೇಶನ್ ನಡವಳಿಕೆಯನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
• ವರ್ಧಿತ ವೀಕ್ಷಣೆ: ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಫ್ಲೋವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳನ್ನು ಗುರುತಿಸಲು ಟ್ರೇಸಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ.
• ಸುಧಾರಿತ ಭದ್ರತೆ: ಸಂದರ್ಭದೊಳಗೆ ಭದ್ರತೆಗೆ ಸಂಬಂಧಿಸಿದ ಮಾಹಿತಿಯನ್ನು (ಉದಾಹರಣೆಗೆ, ದೃಢೀಕರಣ ಟೋಕನ್‌ಗಳು, ದೃಢೀಕರಣ ಪಾತ್ರಗಳು) ನಿರ್ವಹಿಸಿ, ಸ್ಥಿರ ಮತ್ತು ಸುರಕ್ಷಿತ ಪ್ರವೇಶ ನಿಯಂತ್ರಣವನ್ನು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಿ.

AsyncLocalStorage ಮತ್ತು AsyncResource ಬಳಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

AsyncLocalStorage ಮತ್ತು AsyncResource ಶಕ್ತಿಯುತ ಸಾಧನಗಳಾಗಿದ್ದರೂ, ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್ ಮತ್ತು ಸಂಭಾವ್ಯ ಅಪಾಯಗಳನ್ನು ತಪ್ಪಿಸಲು ಅವುಗಳನ್ನು ವಿವೇಚನೆಯಿಂದ ಬಳಸಬೇಕು.

ಸ್ಟೋರ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಿ

ಅಸಿಂಕ್ರೊನಸ್ ಸಂದರ್ಭಕ್ಕೆ ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಿ. ದೊಡ್ಡ ಆಬ್ಜೆಕ್ಟ್‌ಗಳು ಅಥವಾ ಅನಗತ್ಯ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ, ಏಕೆಂದರೆ ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ಮ್ಯಾಪ್‌ಗಳು ಅಥವಾ ಸರಳ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳಂತಹ ಹಗುರವಾದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

ಅತಿಯಾದ ಸಂದರ್ಭ ಬದಲಾವಣೆಯನ್ನು ತಪ್ಪಿಸಿ

`AsyncLocalStorage.run()` ಗೆ ಆಗಾಗ್ಗೆ ಕರೆಗಳು ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಪರಿಚಯಿಸಬಹುದು. ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ಸಂಬಂಧಿತ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಒಂದೇ ಸಂದರ್ಭದಲ್ಲಿ ಗುಂಪು ಮಾಡಿ. AsyncLocalStorage ಸಂದರ್ಭಗಳನ್ನು ಅನಗತ್ಯವಾಗಿ ನೆಸ್ಟ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಿ.

ದೋಷಗಳನ್ನು ನಾಜೂಕಿನಿಂದ ನಿಭಾಯಿಸಿ

AsyncLocalStorage ಸಂದರ್ಭದೊಳಗಿನ ದೋಷಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ನಿರ್ವಹಿಸದ ವಿನಾಯಿತಿಗಳು ಸಂದರ್ಭ ಪ್ರಸರಣ ಸರಪಳಿಯನ್ನು ಅಡ್ಡಿಪಡಿಸುವುದನ್ನು ತಡೆಯಲು try-catch ಬ್ಲಾಕ್‌ಗಳು ಅಥವಾ ದೋಷ ನಿರ್ವಹಣಾ ಮಿಡಲ್‌ವೇರ್ ಅನ್ನು ಬಳಸಿ. ಸುಲಭವಾದ ಡೀಬಗ್ಗಿಂಗ್‌ಗಾಗಿ AsyncLocalStorage ಸ್ಟೋರ್‌ನಿಂದ ಹಿಂಪಡೆಯಲಾದ ಸಂದರ್ಭ-ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯೊಂದಿಗೆ ದೋಷಗಳನ್ನು ಲಾಗ್ ಮಾಡುವುದನ್ನು ಪರಿಗಣಿಸಿ.

AsyncResource ಅನ್ನು ಜವಾಬ್ದಾರಿಯುತವಾಗಿ ಬಳಸಿ

ರಿಸೋರ್ಸ್‌ಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲು ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆ ಪೂರ್ಣಗೊಂಡ ನಂತರ ಯಾವಾಗಲೂ `resource.emitDestroy()` ಅನ್ನು ಕರೆಯಿರಿ. ಹಾಗೆ ಮಾಡಲು ವಿಫಲವಾದರೆ ಮೆಮೊರಿ ಲೀಕ್‌ಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅಸ್ಥಿರತೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಮತ್ತು ನೇಟಿವ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳ ನಡುವಿನ ಅಂತರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಅಗತ್ಯವಿದ್ದಾಗ ಮಾತ್ರ AsyncResource ಅನ್ನು ಬಳಸಿ. ಸಂಪೂರ್ಣವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ, AsyncLocalStorage ಒಂದೇ ಸಾಕಾಗುತ್ತದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಪರಿಗಣಿಸಿ

AsyncLocalStorage ಮತ್ತು AsyncResource ಕೆಲವು ಕಾರ್ಯಕ್ಷಮತೆಯ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತವೆ. ಹೆಚ್ಚಿನ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವೀಕಾರಾರ್ಹವಾಗಿದ್ದರೂ, ಸಂಭಾವ್ಯ ಪರಿಣಾಮದ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ಅತ್ಯಗತ್ಯ, ವಿಶೇಷವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ. ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಪ್ರೊಫೈಲ್ ಮಾಡಿ ಮತ್ತು AsyncLocalStorage ಮತ್ತು AsyncResource ಬಳಸುವ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮವನ್ನು ಅಳೆಯಿರಿ, ಅದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಉದಾಹರಣೆ: AsyncLocalStorage ನೊಂದಿಗೆ ಕಸ್ಟಮ್ ಲಾಗರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು

            const { AsyncLocalStorage } = require('async_hooks');

const asyncLocalStorage = new AsyncLocalStorage();

const logger = {
  log: (message) => {
    const requestId = asyncLocalStorage.getStore()?.get('requestId') || 'N/A';
    console.log(`[${requestId}] ${message}`);
  },
  error: (message) => {
    const requestId = asyncLocalStorage.getStore()?.get('requestId') || 'N/A';
    console.error(`[${requestId}] ERROR: ${message}`);
  },
};

function processRequest(req, res, next) {
  const requestId = Math.random().toString(36).substring(7); // Generate a unique request ID

  asyncLocalStorage.run(new Map(), () => {
    asyncLocalStorage.getStore().set('requestId', requestId);
    logger.log('Request received');
    next(); // Pass control to the next middleware
  });
}

// Example Usage (in an Express.js application)
// app.use(processRequest);
// app.get('/data', (req, res) => {
//   logger.log('Fetching data...');
//   res.send('Data retrieved successfully');
// });

// In case of errors:
// try {
//   // some code that may throw an error
// } catch (error) {
//   logger.error(`An error occurred: ${error.message}`);
//   // ...
// }

            

              
                Copy
              
            
          

ಈ ಉದಾಹರಣೆಯು ಪ್ರತಿ ಲಾಗ್ ಸಂದೇಶದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವಿನಂತಿ ಐಡಿಯನ್ನು ಸೇರಿಸುವ ಕಸ್ಟಮ್ ಲಾಗರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು AsyncLocalStorage ಅನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ. ಇದು ವಿನಂತಿ ಐಡಿಯನ್ನು ಲಾಗಿಂಗ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸುವ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ, ಕೋಡ್ ಅನ್ನು ಸ್ವಚ್ಛವಾಗಿ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.

AsyncLocalStorage ಗೆ ಪರ್ಯಾಯಗಳು

AsyncLocalStorage ಸಂದರ್ಭ ಪ್ರಸರಣಕ್ಕೆ ದೃಢವಾದ ಪರಿಹಾರವನ್ನು ಒದಗಿಸಿದರೂ, ಇತರ ವಿಧಾನಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿ, ಈ ಪರ್ಯಾಯಗಳು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿರಬಹುದು.

ಸ್ಪಷ್ಟ ಸಂದರ್ಭ ರವಾನೆ

ಸರಳವಾದ ವಿಧಾನವೆಂದರೆ ಸಂದರ್ಭ ಡೇಟಾವನ್ನು ಫಂಕ್ಷನ್ ಕರೆಗಳಿಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಾಗಿ ಸ್ಪಷ್ಟವಾಗಿ ರವಾನಿಸುವುದು. ಇದು ಸರಳವಾಗಿದ್ದರೂ, ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೊನಸ್ ಫ್ಲೋಗಳಲ್ಲಿ ಇದು ತೊಡಕಿನ ಮತ್ತು ದೋಷ-ಪೀಡಿತವಾಗಬಹುದು. ಇದು ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಸಂದರ್ಭ ಡೇಟಾಗೆ ಬಿಗಿಯಾಗಿ ಜೋಡಿಸುತ್ತದೆ, ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡ್ಯುಲರ್ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಲಾಗದಂತೆ ಮಾಡುತ್ತದೆ.

cls-hooked (ಸಮುದಾಯ ಮಾಡ್ಯೂಲ್)

`cls-hooked` ಒಂದು ಜನಪ್ರಿಯ ಸಮುದಾಯ ಮಾಡ್ಯೂಲ್ ಆಗಿದ್ದು, ಇದು AsyncLocalStorage ಗೆ ಸಮಾನವಾದ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಆದರೆ Node.js API ಅನ್ನು ಮಂಕಿ-ಪ್ಯಾಚಿಂಗ್ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದನ್ನು ಬಳಸುವುದು ಸುಲಭವಾಗಿದ್ದರೂ, ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ನೇಟಿವ್ AsyncLocalStorage ಅನ್ನು ಬಳಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಹೆಚ್ಚು ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಚಯಿಸುವ ಸಾಧ್ಯತೆ ಕಡಿಮೆ.

ಸಂದರ್ಭ ಪ್ರಸರಣ ಲೈಬ್ರರಿಗಳು

ಹಲವಾರು ಲೈಬ್ರರಿಗಳು ಸಂದರ್ಭ ಪ್ರಸರಣಕ್ಕಾಗಿ ಉನ್ನತ-ಮಟ್ಟದ ಅಮೂರ್ತತೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಈ ಲೈಬ್ರರಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ವಯಂಚಾಲಿತ ಟ್ರೇಸಿಂಗ್, ಲಾಗಿಂಗ್ ಇಂಟಿಗ್ರೇಷನ್, ಮತ್ತು ವಿವಿಧ ಸಂದರ್ಭ ಪ್ರಕಾರಗಳಿಗೆ ಬೆಂಬಲದಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ನೀಡುತ್ತವೆ. ಉದಾಹರಣೆಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಅಥವಾ ವೀಕ್ಷಣಾ ವೇದಿಕೆಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಲೈಬ್ರರಿಗಳು ಸೇರಿವೆ.

ತೀರ್ಮಾನ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ AsyncLocalStorage ಮತ್ತು AsyncResource ಅಸಿಂಕ್ರೊನಸ್ ಕಾರ್ಯಾಚರಣೆಗಳಾದ್ಯಂತ ಸಂದರ್ಭವನ್ನು ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಯುತ ಯಾಂತ್ರಿಕತೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ. ಸ್ಟೋರ್‌ಗಳು, ರನ್‌ಗಳು, ಮತ್ತು ರಿಸೋರ್ಸ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ದೃಢವಾದ, ನಿರ್ವಹಿಸಬಲ್ಲ, ಮತ್ತು ವೀಕ್ಷಿಸಬಹುದಾದ ಅಸಿಂಕ್ರೊನಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಪರ್ಯಾಯಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿದ್ದರೂ, AsyncLocalStorage ಹೆಚ್ಚಿನ ಬಳಕೆಯ ಸಂದರ್ಭಗಳಿಗೆ ನೇಟಿವ್ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ. ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಣಾಮಗಳನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಗಣಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಅಸಿಂಕ್ರೊನಸ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಒಟ್ಟಾರೆ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು ನೀವು AsyncLocalStorage ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಇದು ಇಂದಿನ ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೊನಸ್ ಪರಿಸರದಲ್ಲಿ ಡೀಬಗ್ ಮಾಡಲು ಸುಲಭವಾದ, ಆದರೆ ಹೆಚ್ಚು ಸುರಕ್ಷಿತ, ವಿಶ್ವಾಸಾರ್ಹ, ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಆದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಸಂಭಾವ್ಯ ಮೆಮೊರಿ ಲೀಕ್‌ಗಳನ್ನು ತಡೆಯಲು `AsyncResource` ಬಳಸುವಾಗ `resource.emitDestroy()` ಎಂಬ ನಿರ್ಣಾಯಕ ಹಂತವನ್ನು ಮರೆಯಬೇಡಿ. ಅಸಿಂಕ್ರೊನಸ್ ಸಂದರ್ಭದ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಜಯಿಸಲು ಮತ್ತು ನಿಜವಾಗಿಯೂ ಅಸಾಧಾರಣವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಈ ಉಪಕರಣಗಳನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ.